package com.example.my;

import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class RxJavaActivity extends AppCompatActivity {
    private String TAG = RxJavaActivity.this.getClass().getSimpleName();
    private Button button;
    private TextView text;
    private Integer i;
    // 设置变量
    // 可重试次数
    int maxConnectCount = 10;
    // 当前已重试次数
    int currentRetryCount = 0;
    // 重试等待时间
    int waitRetryTime = 0;
    private String path = "sd/file";

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rxjava);
        initView();
    }

    private void initView() {
        text = findViewById(R.id.text);
        button = findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
            }
        });
        createObservable();
        text.setText(null);
        text.append("你好，");
        text.append("我使用了append");
        text.append("进行字符串拼接");
    }

    /**
     * 创建被观察者
     */
    private void createObservable() {
//        方式1：操作符 create
//        Observable.create(new ObservableOnSubscribe<Integer>() {
//            @Override
//            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
//                emitter.onNext(1);
//                emitter.onNext(2);
//                emitter.onNext(3);
//                emitter.onComplete();
//            }
//        }).subscribe(new Observer<Integer>() {
//            @Override
//            public void onSubscribe(Disposable d) {
//
//            }
//
//            @Override
//            public void onNext(Integer integer) {
//
//            }
//
//            @Override
//            public void onError(Throwable e) {
//
//            }
//
//            @Override
//            public void onComplete() {
//
//            }
//        });

//        方式2：操作符 just
//        Observable.just(1, 2, 3, 4, 5)
//                .subscribe(new Observer<Integer>() {
//                    @Override
//                    public void onSubscribe(Disposable d) {
//                        Log.d(TAG, "开始采用subscribe连接");
//                    }
//
//                    @Override
//                    public void onNext(Integer value) {
//                        Log.d(TAG, "接收到了事件" + value);
//                    }
//
//                    @Override
//                    public void onError(Throwable e) {
//                        Log.d(TAG, "对Error事件作出响应");
//                    }
//
//                    @Override
//                    public void onComplete() {
//                        Log.d(TAG, "对Complete事件作出响应");
//                    }
//                });

//        方式3：操作符 fromArray 可用于数组遍历
//        Integer[] items = {1, 2, 3, 4, 5, 6, 7, 8};
//        Observable.fromArray(items).subscribe(new Observer<Integer>() {
//            @Override
//            public void onSubscribe(Disposable d) {
//                Log.d(TAG, "开始采用subscribe连接");
//            }
//
//            @Override
//            public void onNext(Integer value) {
//                Log.d(TAG, "接收到了事件"+ value  );
//            }
//
//            @Override
//            public void onError(Throwable e) {
//                Log.d(TAG, "对Error事件作出响应");
//            }
//
//            @Override
//            public void onComplete() {
//                Log.d(TAG, "对Complete事件作出响应");
//            }
//        });

//        方式4：操作符 fromIterable 可用作集合遍历
//        List<Integer> list = new ArrayList<>();
//        list.add(1);
//        list.add(2);
//        list.add(3);
//        Observable.fromIterable(list).subscribe(new Observer<Integer>() {
//            @Override
//            public void onSubscribe(Disposable d) {
//                Log.d(TAG, "开始采用subscribe连接");
//            }
//
//            @Override
//            public void onNext(Integer value) {
//                Log.d(TAG, "接收到了事件" + value);
//            }
//
//            @Override
//            public void onError(Throwable e) {
//                Log.d(TAG, "对Error事件作出响应");
//            }
//
//            @Override
//            public void onComplete() {
//                Log.d(TAG, "对Complete事件作出响应");
//            }
//        });

//        方式5：defer 延迟创建
//        i = 10;
//        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
//            @Override
//            public ObservableSource<? extends Integer> call() throws Exception {
//                return Observable.just(i);
//            }
//        });
//        i = 15;
//        observable.subscribe(new Observer<Integer>() {
//            @Override
//            public void onSubscribe(Disposable d) {
//                Log.d(TAG, "开始采用subscribe连接");
//            }
//
//            @Override
//            public void onNext(Integer value) {
//                Log.d(TAG, "接收到的整数是" + value);
//            }
//
//            @Override
//            public void onError(Throwable e) {
//                Log.d(TAG, "对Error事件作出响应");
//            }
//
//            @Override
//            public void onComplete() {
//                Log.d(TAG, "对Complete事件作出响应");
//            }
//        });
        //        方式6：timer 延迟发送
//        Observable.timer(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
//            @Override
//            public void onSubscribe(Disposable d) {
//                Log.d(TAG, "开始采用subscribe连接");
//            }
//
//            @Override
//            public void onNext(Long value) {
//                Log.d(TAG, "接收到了事件"+ value  );
//            }
//
//            @Override
//            public void onError(Throwable e) {
//                Log.d(TAG, "对Error事件作出响应");
//            }
//
//            @Override
//            public void onComplete() {
//                Log.d(TAG, "对Complete事件作出响应");
//            }
//        });
        //        方式7：interval 周期发送
//        Observable.interval(1, 1, TimeUnit.SECONDS)
//                .subscribe(new Observer<Long>() {
//                    @Override
//                    public void onSubscribe(Disposable d) {
//                        Log.d(TAG, "开始采用subscribe连接");
//                    }
//
//                    @Override
//                    public void onNext(Long value) {
//                        Log.d(TAG, "接收到了事件"+ value  );
//                    }
//
//                    @Override
//                    public void onError(Throwable e) {
//                        Log.d(TAG, "对Error事件作出响应");
//                    }
//
//                    @Override
//                    public void onComplete() {
//                        Log.d(TAG, "对Complete事件作出响应");
//                    }
//                });

        //        方式8：do 在某个事件的生命周期中调用
//        Observable.create(new ObservableOnSubscribe<Integer>() {
//            @Override
//            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
//                e.onNext(1);
//                e.onNext(2);
//                e.onNext(3);
////                e.onError(new Throwable("发生错误了"));
//                e.onComplete();
//            }
//        })
//                // 1. 当Observable每发送1次数据事件就会调用1次
//                .doOnEach(new Consumer<Notification<Integer>>() {
//                    @Override
//                    public void accept(Notification<Integer> integerNotification) throws Exception {
//                        Log.d(TAG, "doOnEach: " + integerNotification.getValue());
//                    }
//                })
//                // 2. 执行Next事件前调用
//                .doOnNext(new Consumer<Integer>() {
//                    @Override
//                    public void accept(Integer integer) throws Exception {
//                        Log.d(TAG, "doOnNext: " + integer);
//                    }
//                })
//                // 3. 执行Next事件后调用
//                .doAfterNext(new Consumer<Integer>() {
//                    @Override
//                    public void accept(Integer integer) throws Exception {
//                        Log.d(TAG, "doAfterNext: " + integer);
//                    }
//                })
//                // 4. Observable正常发送事件完毕后调用
//                .doOnComplete(new Action() {
//                    @Override
//                    public void run() throws Exception {
//                        Log.e(TAG, "doOnComplete: ");
//                    }
//                })
//                // 5. Observable发送错误事件时调用
//                .doOnError(new Consumer<Throwable>() {
//                    @Override
//                    public void accept(Throwable throwable) throws Exception {
//                        Log.d(TAG, "doOnError: " + throwable.getMessage());
//                    }
//                })
//                // 6. 观察者订阅时调用
//                .doOnSubscribe(new Consumer<Disposable>() {
//                    @Override
//                    public void accept(@NonNull Disposable disposable) throws Exception {
//                        Log.e(TAG, "doOnSubscribe: ");
//                    }
//                })
//                // 7. Observable发送事件完毕后调用，无论正常发送完毕 / 异常终止
//                .doAfterTerminate(new Action() {
//                    @Override
//                    public void run() throws Exception {
//                        Log.e(TAG, "doAfterTerminate: ");
//                    }
//                })
//                // 8. 最后执行
//                .doFinally(new Action() {
//                    @Override
//                    public void run() throws Exception {
//                        Log.e(TAG, "doFinally: ");
//                    }
//                })
//                .subscribe(new Observer<Integer>() {
//                    @Override
//                    public void onSubscribe(Disposable d) {
//
//                    }
//
//                    @Override
//                    public void onNext(Integer value) {
//                        Log.d(TAG, "接收到了事件" + value);
//                    }
//
//                    @Override
//                    public void onError(Throwable e) {
//                        Log.d(TAG, "对Error事件作出响应");
//                    }
//
//                    @Override
//                    public void onComplete() {
//                        Log.d(TAG, "对Complete事件作出响应");
//                    }
//                });
        //        方式9：onErrorReturn 遇到错误时，发送1个特殊事件 & 正常终止
//        Observable.create(new ObservableOnSubscribe<Integer>() {
//            @Override
//            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
//                emitter.onNext(1);
//                emitter.onNext(2);
//                emitter.onError(new Throwable("发送错误了"));
//            }
//        }).onErrorReturn(new Function<Throwable, Integer>() {
//            @Override
//            public Integer apply(Throwable throwable) throws Exception {
//                // 捕捉错误异常
//                Log.e(TAG, "在onErrorReturn处理了错误: " + throwable.toString());
//                return 666;
//            }
//        }).subscribe(new Observer<Integer>() {
//            @Override
//            public void onSubscribe(Disposable d) {
//
//            }
//
//            @Override
//            public void onNext(Integer value) {
//                Log.d(TAG, "接收到了事件" + value);
//            }
//
//            @Override
//            public void onError(Throwable e) {
//                Log.d(TAG, "对Error事件作出响应");
//            }
//
//            @Override
//            public void onComplete() {
//                Log.d(TAG, "对Complete事件作出响应");
//            }
//        });


    }

//    private void readVideoFileByRXJava() {
//        File rootFile = new File(path);
//        Observable.just(rootFile)
//                .flatMap(new Function<File, ObservableSource<File>>() {
//                    @Override
//                    public ObservableSource<File> apply(File file) throws Exception {
//                        return null;
//                    }
//                });
//    }
//
//
//    private Observable<File> listFiles(File f) {
//        if (f.isDirectory()) {
//            return Observable.fromArray(f.listFiles()).flatMap(new Function<File, ObservableSource<File>>() {
//                @Override
//                public ObservableSource<File> apply(File file) throws Exception {
//                    return listFiles(file);
//                }
//            });
//        } else {
//            return  Observable.just(f).filter(new Function<File,Boolean>());
//        }
//    }
}
